/**
 * Vuex 状态管理配置文件
 * 集中管理应用的状态、操作和数据获取
 */
import { createStore } from 'vuex'
import axios from 'axios'

export default createStore({
  /**
   * 应用全局状态
   * 包含事件、分类、日志、变量等数据
   */
  state: {
    events: [],              // 所有事件列表
    categories: [],          // 所有分类列表
    currentEvent: null,      // 当前选中的事件
    logs: [],                // 当前事件的运行日志
    running: false,          // 事件运行状态
    eventLogs: [],           // 所有事件的日志列表
    currentEventLogs: [],    // 当前事件的历史日志列表
    totalLogs: 0,            // 日志总数（用于分页）
    currentPage: 1,          // 当前页码
    pageSize: 10,            // 每页显示数量
    globalVariables: [],     // 全局变量列表
    eventVariables: [],      // 当前事件的局部变量列表
    allAvailableVariables: [], // 所有可用变量（全局+当前事件局部）
    
    // 自定义节点类型相关状态
    customNodeTypes: [],        // 所有自定义节点类型列表
    currentCustomNodeType: null, // 当前选中的自定义节点类型
    customNodeVersions: [],     // 当前自定义节点类型的所有版本
    publishedVersions: [],       // 已发布的自定义节点类型版本
    variableUsage: {}, // 存储变量被哪些事件使用的信息
    customNodeTypeUsage: {}, // 存储自定义节点类型被哪些事件使用的信息
  },
  /**
   * 状态计算属性
   * 用于从state派生数据，类似计算属性
   */
  getters: {
    /**
     * 根据ID获取事件
     * @param {string} id - 事件ID
     * @returns {Object} 事件对象
     */
    getEventById: (state) => (id) => {
      return state.events.find(event => event.id === id)
    },
    /**
     * 获取指定分类下的所有事件
     * @param {string} categoryId - 分类ID
     * @returns {Array} 事件对象数组
     */
    getEventsByCategory: (state) => (categoryId) => {
      return state.events.filter(event => event.categoryId === categoryId)
    },
    /**
     * 根据ID获取分类
     * @param {string} id - 分类ID
     * @returns {Object} 分类对象
     */
    getCategoryById: (state) => (id) => {
      return state.categories.find(category => category.id === id)
    },
    /**
     * 根据名称获取全局变量
     * @param {string} name - 变量名称
     * @returns {Object} 变量对象
     */
    getGlobalVariableByName: (state) => (name) => {
      return state.globalVariables.find(variable => variable.name === name)
    },
    /**
     * 根据名称获取事件局部变量
     * @param {string} name - 变量名称
     * @returns {Object} 变量对象
     */
    getEventVariableByName: (state) => (name) => {
      return state.eventVariables.find(variable => variable.name === name)
    },
    /**
     * 根据名称获取任意类型变量（全局或局部）
     * @param {string} name - 变量名称
     * @returns {Object} 变量对象
     */
    getVariableByName: (state) => (name) => {
      return state.allAvailableVariables.find(variable => variable.name === name)
    },
    /**
     * 根据ID获取自定义节点类型
     * @param {string} id - 自定义节点类型ID
     * @returns {Object} 自定义节点类型对象
     */
    getCustomNodeTypeById: (state) => (id) => {
      return state.customNodeTypes.find(nodeType => nodeType.id === id)
    },
    /**
     * 根据版本ID获取自定义节点类型版本
     * @param {string} versionId - 版本ID
     * @returns {Object} 版本对象
     */
    getCustomNodeVersionById: (state) => (versionId) => {
      return state.customNodeVersions.find(version => version.id === versionId)
    },
    /**
     * 获取当前已发布版本的自定义节点类型
     * @returns {Array} 已发布的自定义节点类型数组
     */
    getPublishedCustomNodeTypes: (state) => {
      return state.publishedVersions
    }
  },
  /**
   * 状态修改函数
   * 用于同步修改状态，必须通过mutation改变状态
   */
  mutations: {
    /**
     * 设置事件列表
     * @param {Array} events - 事件数组
     */
    SET_EVENTS(state, events) {
      state.events = events
    },
    /**
     * 设置分类列表
     * @param {Array} categories - 分类数组
     */
    SET_CATEGORIES(state, categories) {
      state.categories = categories
    },
    /**
     * 设置当前选中的事件
     * @param {Object} event - 事件对象
     */
    SET_CURRENT_EVENT(state, event) {
      state.currentEvent = event
    },
    /**
     * 添加新事件到列表
     * @param {Object} event - 事件对象
     */
    ADD_EVENT(state, event) {
      state.events.push(event)
    },
    /**
     * 更新事件信息
     * @param {Object} updatedEvent - 更新后的事件对象
     */
    UPDATE_EVENT(state, updatedEvent) {
      const index = state.events.findIndex(e => e.id === updatedEvent.id)
      if (index !== -1) {
        state.events.splice(index, 1, updatedEvent)
      }
    },
    /**
     * 从列表中删除事件
     * @param {string} eventId - 事件ID
     */
    DELETE_EVENT(state, eventId) {
      state.events = state.events.filter(e => e.id !== eventId)
    },
    /**
     * 添加新分类到列表
     * @param {Object} category - 分类对象
     */
    ADD_CATEGORY(state, category) {
      state.categories.push(category)
    },
    /**
     * 更新分类信息
     * @param {Object} updatedCategory - 更新后的分类对象
     */
    UPDATE_CATEGORY(state, updatedCategory) {
      const index = state.categories.findIndex(c => c.id === updatedCategory.id)
      if (index !== -1) {
        state.categories.splice(index, 1, updatedCategory)
      }
    },
    /**
     * 从列表中删除分类
     * @param {string} categoryId - 分类ID
     */
    DELETE_CATEGORY(state, categoryId) {
      state.categories = state.categories.filter(c => c.id !== categoryId)
    },
    /**
     * 添加日志记录
     * @param {Object} log - 日志对象
     */
    ADD_LOG(state, log) {
      state.logs.push(log)
    },
    /**
     * 清空当前日志
     */
    CLEAR_LOGS(state) {
      state.logs = []
    },
    /**
     * 设置事件运行状态
     * @param {boolean} status - 运行状态（true/false）
     */
    SET_RUNNING(state, status) {
      state.running = status
    },
    /**
     * 设置所有事件的日志列表
     * @param {Array} logs - 日志数组
     */
    SET_EVENT_LOGS(state, logs) {
      state.eventLogs = logs
    },
    /**
     * 设置当前事件的历史日志列表
     * @param {Array} logs - 日志数组
     */
    SET_CURRENT_EVENT_LOGS(state, logs) {
      state.currentEventLogs = logs
    },
    /**
     * 设置日志总数
     * @param {number} total - 日志总数量
     */
    SET_TOTAL_LOGS(state, total) {
      state.totalLogs = total
    },
    /**
     * 设置当前页码
     * @param {number} page - 页码
     */
    SET_CURRENT_PAGE(state, page) {
      state.currentPage = page
    },
    /**
     * 设置每页显示数量
     * @param {number} size - 每页条数
     */
    SET_PAGE_SIZE(state, size) {
      state.pageSize = size
    },
    /**
     * 设置全局变量列表
     * @param {Array} variables - 变量数组
     */
    SET_GLOBAL_VARIABLES(state, variables) {
      state.globalVariables = variables
    },
    /**
     * 添加或更新全局变量
     * @param {Object} variable - 变量对象
     */
    ADD_GLOBAL_VARIABLE(state, variable) {
      const index = state.globalVariables.findIndex(v => v.id === variable.id)
      if (index === -1) {
        state.globalVariables.push(variable)
      } else {
        state.globalVariables.splice(index, 1, variable)
      }
    },
    /**
     * 删除全局变量
     * @param {string} variableId - 变量ID
     */
    DELETE_GLOBAL_VARIABLE(state, variableId) {
      state.globalVariables = state.globalVariables.filter(v => v.id !== variableId)
    },
    /**
     * 设置事件局部变量列表
     * @param {Array} variables - 变量数组
     */
    SET_EVENT_VARIABLES(state, variables) {
      state.eventVariables = variables
    },
    /**
     * 添加或更新事件局部变量
     * @param {Object} variable - 变量对象
     */
    ADD_EVENT_VARIABLE(state, variable) {
      const index = state.eventVariables.findIndex(v => v.id === variable.id)
      if (index === -1) {
        state.eventVariables.push(variable)
      } else {
        state.eventVariables.splice(index, 1, variable)
      }
    },
    /**
     * 删除事件局部变量
     * @param {string} variableId - 变量ID
     */
    DELETE_EVENT_VARIABLE(state, variableId) {
      state.eventVariables = state.eventVariables.filter(v => v.id !== variableId)
    },
    /**
     * 设置所有可用变量列表（全局+局部）
     * @param {Array} variables - 变量数组
     */
    SET_ALL_AVAILABLE_VARIABLES(state, variables) {
      state.allAvailableVariables = variables
    },
    /**
     * 设置自定义节点类型列表
     * @param {Array} nodeTypes - 自定义节点类型数组
     */
    SET_CUSTOM_NODE_TYPES(state, nodeTypes) {
      state.customNodeTypes = nodeTypes
    },
    /**
     * 设置当前自定义节点类型
     * @param {Object} nodeType - 自定义节点类型对象
     */
    SET_CURRENT_CUSTOM_NODE_TYPE(state, nodeType) {
      state.currentCustomNodeType = nodeType
    },
    /**
     * 添加新自定义节点类型到列表
     * @param {Object} nodeType - 自定义节点类型对象
     */
    ADD_CUSTOM_NODE_TYPE(state, nodeType) {
      state.customNodeTypes.push(nodeType)
    },
    /**
     * 更新自定义节点类型信息
     * @param {Object} updatedNodeType - 更新后的自定义节点类型对象
     */
    UPDATE_CUSTOM_NODE_TYPE(state, updatedNodeType) {
      const index = state.customNodeTypes.findIndex(n => n.id === updatedNodeType.id)
      if (index !== -1) {
        state.customNodeTypes.splice(index, 1, updatedNodeType)
      }
    },
    /**
     * 从列表中删除自定义节点类型
     * @param {string} nodeTypeId - 自定义节点类型ID
     */
    DELETE_CUSTOM_NODE_TYPE(state, nodeTypeId) {
      state.customNodeTypes = state.customNodeTypes.filter(n => n.id !== nodeTypeId)
    },
    /**
     * 设置自定义节点类型版本列表
     * @param {Array} versions - 版本数组
     */
    SET_CUSTOM_NODE_VERSIONS(state, versions) {
      state.customNodeVersions = versions
    },
    /**
     * 设置已发布的自定义节点类型版本
     * @param {Array} versions - 已发布版本数组
     */
    SET_PUBLISHED_VERSIONS(state, versions) {
      state.publishedVersions = versions
    },
    /**
     * 设置变量使用情况
     * @param {string} variableId - 变量ID
     * @param {Array} events - 使用该变量的事件列表
     */
    SET_VARIABLE_USAGE(state, { variableId, events }) {
      state.variableUsage = {
        ...state.variableUsage,
        [variableId]: events
      }
    },
    /**
     * 设置自定义节点类型使用情况
     * @param {string} nodeTypeId - 自定义节点类型ID
     * @param {Array} events - 使用该节点类型的事件列表
     */
    SET_CUSTOM_NODE_TYPE_USAGE(state, { nodeTypeId, events }) {
      state.customNodeTypeUsage = {
        ...state.customNodeTypeUsage,
        [nodeTypeId]: events
      }
    }
  },
  actions: {
    /**
     * 获取所有事件列表
     * 从API获取所有事件并更新到state中
     */
    async fetchEvents({ commit }) {
      try {
        const response = await axios.get('/api/events')
        commit('SET_EVENTS', response.data)
      } catch (error) {
        console.error('获取事件列表失败:', error)
      }
    },
    
    /**
     * 获取所有分类列表
     * 从API获取所有分类并更新到state中
     */
    async fetchCategories({ commit }) {
      try {
        const response = await axios.get('/api/categories')
        commit('SET_CATEGORIES', response.data)
      } catch (error) {
        console.error('获取分类列表失败:', error)
      }
    },
    
    /**
     * 根据ID获取事件详情
     * @param {string} eventId - 事件ID
     * @returns {Object} 事件详情对象
     */
    async fetchEventById({ commit }, eventId) {
      try {
        const response = await axios.get(`/api/events/${eventId}`)
        commit('SET_CURRENT_EVENT', response.data)
        return response.data
      } catch (error) {
        console.error('获取事件详情失败:', error)
      }
    },
    
    /**
     * 创建新事件
     * @param {Object} event - 事件对象数据
     * @returns {Object} 创建成功后的事件对象
     */
    async createEvent({ commit }, event) {
      try {
        const response = await axios.post('/api/events', event)
        commit('ADD_EVENT', response.data)
        return response.data
      } catch (error) {
        console.error('创建事件失败:', error)
      }
    },
    
    /**
     * 更新事件信息
     * @param {Object} payload - 包含id和event对象的参数
     * @param {string} payload.id - 事件ID
     * @param {Object} payload.event - 更新后的事件对象
     * @returns {Object} 更新成功后的事件对象
     */
    async updateEvent({ commit }, { id, event }) {
      try {
        const response = await axios.put(`/api/events/${id}`, event)
        commit('UPDATE_EVENT', response.data)
        return response.data
      } catch (error) {
        console.error('更新事件失败:', error)
      }
    },
    
    /**
     * 删除事件
     * @param {string} eventId - 要删除的事件ID
     */
    async deleteEvent({ commit }, eventId) {
      try {
        await axios.delete(`/api/events/${eventId}`)
        commit('DELETE_EVENT', eventId)
      } catch (error) {
        console.error('删除事件失败:', error)
      }
    },
    
    /**
     * 创建新分类
     * @param {Object} category - 分类对象数据
     * @returns {Object} 创建成功后的分类对象
     */
    async createCategory({ commit }, category) {
      try {
        const response = await axios.post('/api/categories', category)
        commit('ADD_CATEGORY', response.data)
        return response.data
      } catch (error) {
        console.error('创建分类失败:', error)
      }
    },
    
    /**
     * 更新分类信息
     * @param {Object} payload - 包含id和category对象的参数
     * @param {string} payload.id - 分类ID
     * @param {Object} payload.category - 更新后的分类对象
     * @returns {Object} 更新成功后的分类对象
     */
    async updateCategory({ commit }, { id, category }) {
      try {
        const response = await axios.put(`/api/categories/${id}`, category)
        commit('UPDATE_CATEGORY', response.data)
        return response.data
      } catch (error) {
        console.error('更新分类失败:', error)
      }
    },
    
    /**
     * 删除分类
     * @param {string} categoryId - 要删除的分类ID
     */
    async deleteCategory({ commit }, categoryId) {
      try {
        await axios.delete(`/api/categories/${categoryId}`)
        commit('DELETE_CATEGORY', categoryId)
      } catch (error) {
        console.error('删除分类失败:', error)
      }
    },
    
    /**
     * 运行事件
     * 清空日志，设置运行状态，并向API发送运行请求
     * @param {string} eventId - 要运行的事件ID
     * @returns {Object} 运行结果数据
     */
    async runEvent({ commit }, eventId) {
      commit('CLEAR_LOGS')
      commit('SET_RUNNING', true)
      try {
        const response = await axios.post(`/api/events/${eventId}/run`)
        
        if (response.data.logs) {
          response.data.logs.forEach(log => {
            commit('ADD_LOG', log)
          })
        }
        
        return response.data
      } catch (error) {
        console.error('运行事件失败:', error)
      } finally {
        commit('SET_RUNNING', false)
      }
    },
    
    /**
     * 添加日志项
     * @param {Object} log - 日志对象
     */
    addLog({ commit }, log) {
      commit('ADD_LOG', log)
    },
    
    /**
     * 获取所有事件的日志列表
     * @param {Object} params - 分页参数
     * @param {number} [params.page=1] - 页码
     * @param {number} [params.limit=10] - 每页条数
     * @returns {Object} 包含日志数据和分页信息的对象
     */
    async fetchAllEventLogs({ commit }, { page = 1, limit = 10 }) {
      try {
        const response = await axios.get(`/api/logs?page=${page}&limit=${limit}`)
        commit('SET_EVENT_LOGS', response.data.data)
        commit('SET_TOTAL_LOGS', response.data.total)
        commit('SET_CURRENT_PAGE', page)
        commit('SET_PAGE_SIZE', limit)
        return response.data
      } catch (error) {
        console.error('获取所有事件日志失败:', error)
      }
    },
    
    /**
     * 获取特定事件的日志列表
     * @param {Object} params - 参数对象
     * @param {string} params.eventId - 事件ID
     * @param {number} [params.page=1] - 页码
     * @param {number} [params.limit=10] - 每页条数
     * @returns {Object} 包含日志数据和分页信息的对象
     */
    async fetchEventLogs({ commit }, { eventId, page = 1, limit = 10 }) {
      try {
        const response = await axios.get(`/api/logs/event/${eventId}?page=${page}&limit=${limit}`)
        commit('SET_CURRENT_EVENT_LOGS', response.data.data)
        commit('SET_TOTAL_LOGS', response.data.total)
        commit('SET_CURRENT_PAGE', page)
        commit('SET_PAGE_SIZE', limit)
        return response.data
      } catch (error) {
        console.error(`获取事件 ${eventId} 的日志失败:`, error)
      }
    },
    
    /**
     * 获取日志详情
     * @param {string} logId - 日志ID
     * @returns {Object} 日志详情对象
     */
    async getLogDetail(_, logId) {
      try {
        const response = await axios.get(`/api/logs/${logId}`)
        return response.data
      } catch (error) {
        console.error('获取日志详情失败:', error)
      }
    },
    
    /**
     * 删除日志
     * @param {string} logId - 要删除的日志ID
     * @returns {boolean} 操作是否成功
     */
    async deleteLog({ dispatch, state }, logId) {
      try {
        await axios.delete(`/api/logs/${logId}`)
        await dispatch('fetchAllEventLogs', { 
          page: state.currentPage, 
          limit: state.pageSize 
        })
        return true
      } catch (error) {
        console.error('删除日志失败:', error)
        return false
      }
    },
    
    /**
     * 清空特定事件的所有日志
     * @param {string} eventId - 事件ID
     * @returns {boolean} 操作是否成功
     */
    async clearEventLogs({ dispatch }, eventId) {
      try {
        await axios.delete(`/api/logs/event/${eventId}/clear`)
        await dispatch('fetchEventLogs', { eventId, page: 1 })
        return true
      } catch (error) {
        console.error('清空事件日志失败:', error)
        return false
      }
    },
    
    /**
     * 获取全局变量列表
     * 从API获取所有全局变量并更新到state中
     * @returns {Array} 全局变量数组
     */
    async fetchGlobalVariables({ commit }) {
      try {
        const response = await axios.get('/api/variables/global')
        commit('SET_GLOBAL_VARIABLES', response.data)
        return response.data
      } catch (error) {
        console.error('获取全局变量列表失败:', error)
      }
    },
    
    /**
     * 创建或更新全局变量
     * @param {Object} variable - 变量对象
     * @returns {Object} 创建或更新后的变量对象
     */
    async saveGlobalVariable({ commit }, variable) {
      try {
        const response = await axios.post('/api/variables/global', variable)
        commit('ADD_GLOBAL_VARIABLE', response.data)
        return response.data
      } catch (error) {
        console.error('保存全局变量失败:', error)
        throw error
      }
    },
    
    /**
     * 删除全局变量
     * @param {string} variableId - 要删除的变量ID
     * @returns {boolean} 操作是否成功
     */
    async deleteGlobalVariable({ commit }, variableId) {
      try {
        await axios.delete(`/api/variables/global/${variableId}`)
        commit('DELETE_GLOBAL_VARIABLE', variableId)
        return true
      } catch (error) {
        console.error('删除全局变量失败:', error)
        return false
      }
    },
    
    /**
     * 获取事件局部变量列表
     * @param {string} eventId - 事件ID
     * @returns {Array} 事件局部变量数组
     */
    async fetchEventVariables({ commit }, eventId) {
      try {
        const response = await axios.get(`/api/variables/event/${eventId}`)
        commit('SET_EVENT_VARIABLES', response.data)
        return response.data
      } catch (error) {
        console.error(`获取事件 ${eventId} 的局部变量列表失败:`, error)
      }
    },
    
    /**
     * 创建或更新事件局部变量
     * @param {Object} payload - 参数对象
     * @param {string} payload.eventId - 事件ID
     * @param {Object} payload.variable - 变量对象
     * @returns {Object} 创建或更新后的变量对象
     */
    async saveEventVariable({ commit }, { eventId, variable }) {
      try {
        const response = await axios.post(`/api/variables/event/${eventId}`, variable)
        commit('ADD_EVENT_VARIABLE', response.data)
        return response.data
      } catch (error) {
        console.error('保存事件局部变量失败:', error)
        throw error
      }
    },
    
    /**
     * 删除事件局部变量
     * @param {Object} payload - 参数对象
     * @param {string} payload.eventId - 事件ID
     * @param {string} payload.variableId - 变量ID
     * @returns {boolean} 操作是否成功
     */
    async deleteEventVariable({ commit }, { eventId, variableId }) {
      try {
        await axios.delete(`/api/variables/event/${eventId}/${variableId}`)
        commit('DELETE_EVENT_VARIABLE', variableId)
        return true
      } catch (error) {
        console.error('删除事件局部变量失败:', error)
        return false
      }
    },
    
    /**
     * 清空事件局部变量
     * @param {string} eventId - 事件ID
     * @returns {boolean} 操作是否成功
     */
    async clearEventVariables({ commit }, eventId) {
      try {
        await axios.delete(`/api/variables/event/${eventId}/clear`)
        commit('SET_EVENT_VARIABLES', [])
        return true
      } catch (error) {
        console.error('清空事件局部变量失败:', error)
        return false
      }
    },
    
    /**
     * 获取事件所有可用变量（全局+局部）
     * @param {string} eventId - 事件ID
     * @returns {Array} 所有可用变量数组
     */
    async fetchAllAvailableVariables({ commit }, eventId) {
      try {
        const response = await axios.get(`/api/variables/event/${eventId}/all`)
        commit('SET_ALL_AVAILABLE_VARIABLES', response.data)
        return response.data
      } catch (error) {
        console.error(`获取事件 ${eventId} 所有可用变量失败:`, error)
      }
    },
    
    /**
     * 获取所有自定义节点类型列表
     * 从API获取所有自定义节点类型并更新到state中
     */
    async fetchCustomNodeTypes({ commit }) {
      try {
        const response = await axios.get('/api/custom-node-types')
        commit('SET_CUSTOM_NODE_TYPES', response.data)
        return response.data
      } catch (error) {
        console.error('获取自定义节点类型列表失败:', error)
      }
    },
    
    /**
     * 根据ID获取自定义节点类型详情
     * @param {string} nodeTypeId - 自定义节点类型ID
     * @returns {Object} 自定义节点类型详情对象
     */
    async fetchCustomNodeTypeById({ commit }, nodeTypeId) {
      try {
        const response = await axios.get(`/api/custom-node-types/${nodeTypeId}`)
        commit('SET_CURRENT_CUSTOM_NODE_TYPE', response.data)
        return response.data
      } catch (error) {
        console.error('获取自定义节点类型详情失败:', error)
      }
    },
    
    /**
     * 创建新自定义节点类型
     * @param {Object} nodeType - 自定义节点类型对象数据
     * @returns {Object} 创建成功后的自定义节点类型对象
     */
    async createCustomNodeType({ commit }, nodeType) {
      try {
        const response = await axios.post('/api/custom-node-types', nodeType)
        commit('ADD_CUSTOM_NODE_TYPE', response.data)
        return response.data
      } catch (error) {
        console.error('创建自定义节点类型失败:', error)
        throw error
      }
    },
    
    /**
     * 更新自定义节点类型信息
     * @param {Object} payload - 包含id和nodeType对象的参数
     * @param {string} payload.id - 自定义节点类型ID
     * @param {Object} payload.nodeType - 更新后的自定义节点类型对象
     * @returns {Object} 更新成功后的自定义节点类型对象
     */
    async updateCustomNodeType({ commit }, { id, nodeType }) {
      try {
        const response = await axios.put(`/api/custom-node-types/${id}`, nodeType)
        commit('UPDATE_CUSTOM_NODE_TYPE', response.data)
        return response.data
      } catch (error) {
        console.error('更新自定义节点类型失败:', error)
        throw error
      }
    },
    
    /**
     * 删除自定义节点类型
     * @param {string} nodeTypeId - 要删除的自定义节点类型ID
     * @returns {boolean} 是否删除成功
     */
    async deleteCustomNodeType({ commit }, nodeTypeId) {
      try {
        await axios.delete(`/api/custom-node-types/${nodeTypeId}`)
        commit('DELETE_CUSTOM_NODE_TYPE', nodeTypeId)
        return true
      } catch (error) {
        console.error('删除自定义节点类型失败:', error)
        return false
      }
    },
    
    /**
     * 获取自定义节点类型的所有版本
     * @param {string} nodeTypeId - 自定义节点类型ID
     * @returns {Array} 版本列表
     */
    async fetchCustomNodeVersions({ commit }, nodeTypeId) {
      try {
        const response = await axios.get(`/api/custom-node-types/${nodeTypeId}/versions`)
        commit('SET_CUSTOM_NODE_VERSIONS', response.data)
        return response.data
      } catch (error) {
        console.error('获取自定义节点类型版本列表失败:', error)
      }
    },
    
    /**
     * 创建自定义节点类型的新版本
     * @param {Object} payload - 包含nodeTypeId和version对象的参数
     * @param {string} payload.nodeTypeId - 自定义节点类型ID
     * @param {Object} payload.version - 版本信息对象
     * @returns {Object} 创建成功后的版本对象
     */
    async createCustomNodeVersion({ commit, dispatch }, { nodeTypeId, version }) {
      try {
        const response = await axios.post(`/api/custom-node-types/${nodeTypeId}/versions`, version)
        await dispatch('fetchCustomNodeVersions', nodeTypeId)
        return response.data
      } catch (error) {
        console.error('创建自定义节点类型版本失败:', error)
        throw error
      }
    },
    
    /**
     * 发布自定义节点类型的指定版本
     * @param {Object} payload - 包含nodeTypeId和versionId的参数
     * @param {string} payload.nodeTypeId - 自定义节点类型ID
     * @param {string} payload.versionId - 版本ID
     * @returns {Object} 发布结果
     */
    async publishCustomNodeVersion({ commit, dispatch }, { nodeTypeId, versionId }) {
      try {
        const response = await axios.post(`/api/custom-node-types/${nodeTypeId}/versions/${versionId}/publish`)
        await dispatch('fetchPublishedVersions')
        return response.data
      } catch (error) {
        console.error('发布自定义节点类型版本失败:', error)
        throw error
      }
    },
    
    /**
     * 获取所有已发布的自定义节点类型版本
     * @returns {Array} 已发布版本列表
     */
    async fetchPublishedVersions({ commit }) {
      try {
        const response = await axios.get('/api/custom-node-types/published')
        commit('SET_PUBLISHED_VERSIONS', response.data)
        return response.data
      } catch (error) {
        console.error('获取已发布自定义节点类型版本列表失败:', error)
      }
    },
    
    /**
     * 获取变量被哪些事件使用
     * @param {Object} context - Vuex 上下文
     * @param {Object} payload - 参数对象
     * @param {string} payload.variableId - 变量ID
     * @param {string} payload.variableType - 变量类型 (global/event)
     * @param {number} payload.page - 页码
     * @param {number} payload.pageSize - 每页数量
     * @returns {Object} 使用该变量的事件列表和分页信息
     */
    async fetchVariableUsage({ commit }, { variableId, variableType, page = 1, pageSize = 10 }) {
      try {
        const response = await axios.get(`/api/variables/${variableType}/${variableId}/usage`, {
          params: { page, pageSize }
        })
        commit('SET_VARIABLE_USAGE', { variableId, events: response.data.events })
        return response.data
      } catch (error) {
        console.error(`获取变量使用情况失败:`, error)
        throw error
      }
    },
    
    /**
     * 获取自定义节点类型被哪些事件使用
     * @param {Object} context - Vuex 上下文
     * @param {Object} payload - 参数对象
     * @param {string} payload.nodeTypeId - 自定义节点类型ID
     * @param {number} payload.page - 页码
     * @param {number} payload.pageSize - 每页数量
     * @returns {Object} 使用该自定义节点类型的事件列表和分页信息
     */
    async fetchCustomNodeTypeUsage({ commit }, { nodeTypeId, page = 1, pageSize = 10 }) {
      try {
        const response = await axios.get(`/api/custom-node-types/${nodeTypeId}/usage`, {
          params: { page, pageSize }
        })
        commit('SET_CUSTOM_NODE_TYPE_USAGE', { nodeTypeId, events: response.data.events })
        return response.data
      } catch (error) {
        console.error(`获取自定义节点类型使用情况失败:`, error)
        throw error
      }
    },
    
    /**
     * 更新所有事件的数据架构
     * 将自定义节点引用从节点层移到版本层
     * @returns {Object} API响应结果
     */
    async updateEventsSchema({ commit }) {
      try {
        const response = await axios.post('/api/events/update-schema')
        return response.data
      } catch (error) {
        console.error('更新事件数据架构失败:', error)
        throw error
      }
    },

    /**
     * 获取引用特定版本的事件列表
     * @param {Object} context - Vuex 上下文
     * @param {Object} payload - 参数对象
     * @param {string} payload.versionId - 版本ID
     * @param {number} payload.page - 页码
     * @param {number} payload.pageSize - 每页数量
     * @returns {Object} 引用该版本的事件列表和分页信息
     */
    async fetchVersionEvents({ commit }, { versionId, page = 1, pageSize = 10 }) {
      try {
        const response = await axios.get(`/api/custom-node-types/versions/${versionId}/events`, {
          params: { page, pageSize }
        })
        return response.data
      } catch (error) {
        console.error('获取引用版本的事件列表失败:', error)
        throw error
      }
    }
  }
}) 